/*
 * Copyright 2010-2011 ESunny.com All right reserved. This software is the confidential and proprietary information of
 * ESunny.com ("Confidential Information"). You shall not disclose such Confidential Information and shall use it only
 * in accordance with the terms of the license agreement you entered into with ESunny.com.
 */
package com.xjt.common;

import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.apache.commons.collections.CollectionUtils;
import org.apache.commons.collections.MapUtils;
import org.apache.commons.lang.StringEscapeUtils;
import org.apache.commons.lang.StringUtils;
import org.apache.oro.text.regex.MalformedPatternException;
import org.apache.oro.text.regex.Pattern;
import org.apache.oro.text.regex.PatternMatcher;
import org.apache.oro.text.regex.Perl5Compiler;
import org.apache.oro.text.regex.Perl5Matcher;
import org.apache.oro.text.regex.Perl5Substitution;
import org.apache.oro.text.regex.Util;

public class VelocityHelper {

    private static final String        BLANK         = " ";
    private static final String        EMPTY         = "";
    private static final String        ABRIDGED      = "...";
    private static final String        HIGHLIGHTPRE  = "<em>";
    private static final String        HIGHLIGHTPOST = "</em>";
    private static final String        RMB_CN        = "人民币";
    private static final String        RMB_EN        = "￥";
    private static final String        YUAN          = "元";
    private static final String        YI            = "亿";
    private static final String        WAN           = "万";

    private static Pattern             BLANK_PATTERN = null;
    private static Pattern             RMB_PATTERN   = null;
    private static Pattern             YUAN_PATTERN  = null;
    private static Pattern             WAN_PATTERN   = null;
    private static Pattern             YI_PATTERN    = null;

    static {
        try {
            BLANK_PATTERN = new Perl5Compiler().compile(BLANK);
            RMB_PATTERN = new Perl5Compiler().compile(RMB_CN);
            YUAN_PATTERN = new Perl5Compiler().compile(YUAN);
            WAN_PATTERN = new Perl5Compiler().compile(WAN);
            YI_PATTERN = new Perl5Compiler().compile(YI);
        } catch (MalformedPatternException e) {
            // ignore
        }
    }

    /**
     * 用来把地区'长名'换成'短名'的后缀
     */
    protected static final Set<String> sufFilterSet;

    static {
        sufFilterSet = new LinkedHashSet<String>();
        sufFilterSet.add("回族自治区");
        sufFilterSet.add("维吾尔自治区");
        sufFilterSet.add("壮族自治区");
        sufFilterSet.add("自治区");
        sufFilterSet.add("自治州");
        sufFilterSet.add("省");
        sufFilterSet.add("市");
    }

    /**
     * js字符串转码 - 替换特殊字符
     * 
     * @param val
     * @return
     */
    public String sjs(String val) {
        return StringEscapeUtils.escapeJavaScript(val);
    }

    /**
     * 判断对象是否为空，或者空字符串
     * 
     * @param obj
     * @return true 为空 false不为空
     */
    public Boolean isEmpty(Object obj) {
        if (obj == null) {
            return true;
        }
        return StringUtils.isBlank(obj.toString());
    }

    /**
     * xml字符串转码 - 替换特殊字符
     * 
     * @param val
     * @return
     */
    public String sxml(String val) {
        return StringEscapeUtils.escapeXml(val);
    }

    /**
     * html字符串转码 - 替换特殊字符
     * 
     * @param val
     * @return
     */
    public String shtml(String val) {
        return StringEscapeUtils.escapeHtml(val);
    }

    /**
     * 取字符串的第index位字符
     * 
     * @param str
     * @param index
     * @return
     */
    public Character getChar(String str, int index) {
        return (null != str && str.length() > index) ? str.charAt(index) : null;
    }

    public String getStr(String str, int index) {
        return (null != str && str.length() > index) ? String.valueOf(str.charAt(index)) : EMPTY;
    }

    /**
     * 取字符串数组第index
     * 
     * @param strs
     * @param index
     * @return
     */

    public String getStr(String[] strs, int index) {
        return (null != strs && strs.length > index) ? strs[index] : EMPTY;
    }

    public String getStr(List<String> strs, int index) {
        return (null != strs && strs.size() > index) ? strs.get(index) : EMPTY;
    }

    /**
     * 字符串截取
     */
    public String left(String str, int index) {
        if (StringUtils.isBlank(str)) {
            return EMPTY;
        }
        if (str.length() < index) {
            return StringEscapeUtils.escapeHtml(str);
        } else {
            return StringEscapeUtils.escapeHtml(str.substring(0, index));
        }
    }

    /**
     * 字符串截取,可加入后缀（一般为省略号）
     */
    public String left(String str, int index, String suffix) {
        if (StringUtils.isBlank(str)) {
            return EMPTY;
        }
        if (str.length() < index) {
            return StringEscapeUtils.escapeHtml(str);
        } else {
            return StringEscapeUtils.escapeHtml(str.substring(0, index - suffix.length())) + suffix;
        }
    }

    /**
     * 对传进来的str1和str2进行拼接，然后进行截取
     * 
     * @param str1 字符串1
     * @param str2 字符串2
     * @param max 最大长度
     * @param splitIndex 超过后的截取长度
     * @param suffix 后缀名
     * @return 处理好的str
     */
    public String leftStr(String str1, String str2, int max, int splitIndex, String suffix) {
        StringBuilder sbd = new StringBuilder();
        if (StringUtils.isBlank(str1) && StringUtils.isBlank(str2)) {
            return null;
        }

        if (!StringUtils.isBlank(str1)) {
            sbd.append(str1);
        }

        if (!StringUtils.isBlank(str2)) {
            sbd.append(str2);
        }

        if (StringUtils.isBlank(sbd.toString())) {
            return null;
        }

        String handleStr = sbd.toString().trim();
        if (handleStr.length() <= max) {
            return StringEscapeUtils.escapeHtml(handleStr);
        } else {
            return StringEscapeUtils.escapeHtml(handleStr.substring(0, splitIndex)) + suffix;
        }
    }

    public String substring(String str, int beginindex, int endindex) {
        if (null == str || str.length() < beginindex) return EMPTY;
        if (endindex > str.length()) endindex = str.length();
        return str.substring(beginindex, endindex);
    }

    /**
     * 取字符串中某字符的左/右侧
     * 
     * @param args
     */
    public String leftStr(String str, String s) {
        if (null == str || null == s) return EMPTY;
        int index = str.indexOf(s);
        if (index < 0) return EMPTY;
        return StringEscapeUtils.escapeHtml(str.substring(0, index));
    }

    /**
     * 对字符串的长度进行截取 方法说明：对指定的STR进行截取，如果超过了max指定的长度则按照min指定的长度进行截取,然后了suffix进行填充
     * 
     * @param str 需要截取的字符串
     * @param max 最大长度
     * @param splitIndex 超过后从第几位进行截取
     * @param suffix 截取字符串的后缀
     * @return 处理好的字符串后缀
     */
    public String leftStr(String str, int max, int splitIndex, String suffix) {
        if (StringUtils.isBlank(str)) {
            return null;
        }
        String handleStr = str.trim();
        if (handleStr.length() <= max) {
            return StringEscapeUtils.escapeHtml(handleStr);
        } else {
            return StringEscapeUtils.escapeHtml(handleStr.substring(0, splitIndex)) + suffix;
        }
    }

    /**
     * 字符的截取 如果是英文，那么它所需要截取的长度乘以2，否则按正常的截取
     * 
     * @param str
     * @param max
     * @param splitIndex
     * @param suffix
     * @return
     */
    public static String leftStrLetter(String str, int max, int splitIndex, String suffix) {
        if (StringUtils.isBlank(str)) {
            return null;
        }
        // 去掉空格
        String convertStr = replace(BLANK_PATTERN, EMPTY, str);

        // 转成char
        char[] strArray = convertStr.toCharArray();

        // 是否是字母
        Boolean isLetter = true;
        for (int i = 0; i < strArray.length; i++) {
            // 如果里面含有汉字 直接退出
            if (((strArray[i] >= 0x0391 && strArray[i] <= 0xFFE5))) {
                isLetter = false;
                continue;
            }
        }
        // 字母的处理
        if (isLetter) {
            if (str.length() <= max * 2) {
                return str;
            } else {
                return str.substring(0, splitIndex * 2) + suffix;
            }
        } else {
            // 汉字的处理
            if (str.length() <= max) {
                return str;
            } else {
                return str.substring(0, splitIndex) + suffix;
            }
        }
    }

    public String rightStr(String str, String s) {
        if (null == str || null == s) return EMPTY;
        int index = str.indexOf(s);
        if (index < 0) return EMPTY;
        return str.substring(index + 1);
    }

    /**
     * 字符串分割
     * 
     * @param args
     */
    public String[] split(String str, String s) {
        return StringUtils.split(str, s);
    }

    /**
     * 页面上字符串长度截取
     */
    public String lstr(String s, Integer lens) {
        if (null == s || s.length() <= lens) return s;
        return s.substring(0, lens - 3) + ABRIDGED;
    }

    /**
     * 高亮处理
     */
    public static final String getHighlight(Map<Integer, List<Integer>> postion, String s2) {
        if (MapUtils.isEmpty(postion)) {
            return s2;
        } else {
            return highlight(s2, postion);
        }
    }

    public static final String getHighlight(Map<Integer, List<Integer>> postion, String s2, Integer lens) {
        List<Integer> preList = postion.get(0);
        List<Integer> postList = postion.get(1);

        int endPost = postList.get(postList.size() - 1);
        // 是否可以到高亮的最后
        if (endPost > lens) {
            int startPre = preList.get(0);
            int il = endPost - startPre;
            if (il < lens) {
                int cs = lens - il - 3; // 还差几个字符
                if (cs > startPre) {
                    return highlight(s2.substring(0, lens - 3), postion, startPre) + ABRIDGED;
                } else {
                    int ics = (cs > 0) ? (startPre - cs) : startPre;
                    return highlight(s2.substring(ics, ics + lens - 3), postion, ics) + ABRIDGED;
                }
            } else {
                return highlight(s2.substring(startPre, startPre + lens - 3), postion, startPre) + ABRIDGED;
            }
        } else {
            if (s2.length() > lens) {
                return highlight(s2.substring(0, lens - 3), postion) + ABRIDGED;
            } else {
                return highlight(s2, postion);
            }
        }

    }

    /** 高亮处理 */
    private final static String highlight(String res, Map<Integer, List<Integer>> pos) {
        List<Integer> preList = pos.get(0);
        List<Integer> postList = pos.get(1);

        StringBuilder sb = new StringBuilder(res);
        for (int i = preList.size(); i > 0;) {
            i--;
            if (postList.get(i) > res.length() || postList.get(i).equals(preList.get(i))) {
                continue;
            }
            // 先插post，因为sb的index插完会变
            sb.insert(postList.get(i), HIGHLIGHTPOST);
            // 再插 pre
            sb.insert(preList.get(i), HIGHLIGHTPRE);
        }
        return sb.toString();
    }

    /** 高亮处理 - 带偏移量 */
    private final static String highlight(String res, Map<Integer, List<Integer>> pos, int start) {
        List<Integer> preList = pos.get(0);
        List<Integer> postList = pos.get(1);

        StringBuilder sb = new StringBuilder(res);
        for (int i = preList.size(); i > 0;) {
            i--;
            int pre = preList.get(i).intValue() - start;
            int post = postList.get(i).intValue() - start;
            if (post > res.length() || pre < 0) {
                continue;
            }
            sb.insert(post, HIGHLIGHTPOST);
            sb.insert(pre, HIGHLIGHTPRE);
        }
        return sb.toString();
    }

    /**
     * 对地区名称的过滤. <li>主要是针对取出来的地区名称进行处理</li> <li>比如取出来的地区名称是"杭州市;",那么处理后应该是"杭州"</li>
     * 
     * @param regionName 地区名称.
     * @return 处理后的地区名称.
     */
    public static String areaNameFilter(String regionName) {
        for (String suffix : sufFilterSet) {
            if (null == suffix) {
                continue;
            }
            if (!StringUtils.isBlank(regionName)) {
                // 如果包含需要过滤的字符串则过滤掉
                if (regionName.endsWith(suffix)) {
                    regionName = regionName.substring(0, regionName.length() - suffix.length());
                    return regionName;
                }
            }
        }
        return regionName;
    }

    /**
     * 两个对象之间的比较 <li>注：传进去的对象不能为空，如果为空，则返回false</li>
     * 
     * @param str1 对象1
     * @param str2 对象2
     * @return 相同 true 不相同 false
     */
    public static Boolean equals(String str1, String str2) {
        return StringUtils.equals(str1, str2);
    }

    /**
     * 高亮关键字
     * 
     * @param str 需要高亮的字符串
     * @param keyList 关键字列表
     * @param className 高亮的类名
     * @return 高亮后的字符串
     */
    public static String addHighlight(String str, List<String> keyList, String className) {
        if (StringUtils.isBlank(str) || CollectionUtils.isEmpty(keyList)) {
            return str;
        }
        for (String key : keyList) {
            if (str.contains(key)) {
                str = str.replace(key, "<span class='" + className + "'>" + key + "</span>");
            }
        }
        return str;
    }

    /**
     * 公司年营业额的数据格式转化. 格式：<li>人民币10万元以下---->￥10万以下</li> <li>人民币30万元-50万元---->￥30-50万</li> <li>人民币5000万元-1亿元---->￥5000万-1亿
     * </li><li>人民币1亿元以上---->￥1亿以上</li>
     * 
     * @param tradeAmount 年营业额
     * @return 转化后的数据格式
     */
    public static String companyTradeAmountFiler(String tradeAmount) {
        String handleTradeAmount = EMPTY;
        if (StringUtils.isBlank(tradeAmount)) {
            return handleTradeAmount;
        }
        handleTradeAmount = replace(RMB_PATTERN, RMB_EN, tradeAmount);
        // 对“人民币5000万元-1亿元”的处理
        if (StringUtils.indexOf(tradeAmount, "-") != -1 && StringUtils.indexOf(tradeAmount, WAN) != -1
            && StringUtils.indexOf(tradeAmount, YI) != -1) {
            handleTradeAmount = replace(YUAN_PATTERN, EMPTY, handleTradeAmount);
            return handleTradeAmount;
        }
        // 对"人民币30万元-50万元"的处理----￥30-50万
        else if (StringUtils.indexOf(tradeAmount, "-") != -1 && VelocityHelper.isRepeat(tradeAmount, '万') == 2) {
            handleTradeAmount = replace(WAN_PATTERN, EMPTY, handleTradeAmount);
            handleTradeAmount = replace(YUAN_PATTERN, EMPTY, handleTradeAmount);
            return handleTradeAmount + WAN;
            // 对"人民币30亿-50亿"的处理
        } else if (StringUtils.indexOf(tradeAmount, "-") != -1 && VelocityHelper.isRepeat(tradeAmount, '亿') == 2) {
            handleTradeAmount = replace(YI_PATTERN, EMPTY, handleTradeAmount);
            handleTradeAmount = replace(YUAN_PATTERN, EMPTY, handleTradeAmount);
            return handleTradeAmount + YI;
        } else {
            return replace(YUAN_PATTERN, EMPTY, handleTradeAmount);
        }

    }

    /**
     * 检查某个字符是否在字符串中重复出现
     * 
     * @param str1 需要检查的字符串
     * @param str2 重复的字符
     * @return 返回该字符出现的次数
     */
    public static int isRepeat(String str1, char char2) {
        int num = 0;
        if (StringUtils.isBlank(str1) && StringUtils.isBlank(String.valueOf(char2))) {
            return num;
        }
        char[] chararray = str1.toCharArray();
        if (chararray.length > 0) {
            for (int i = 0; i < chararray.length; i++) {
                if (chararray[i] == char2) {
                    num += 1;
                }
            }
        }
        return num;
    }

    /**
     * 给指定的文本进行替换操作
     * 
     * @param pattern 替换的pattern
     * @param replacement 替换的内容
     * @param content 原文
     * @return 替换后的内容
     */
    private static String replace(Pattern pattern, String replacement, String content) {
        PatternMatcher matcher = new Perl5Matcher();
        return Util.substitute(matcher, pattern, new Perl5Substitution(replacement), content, Util.SUBSTITUTE_ALL);
    }

    /**
     * 高亮关键字(左边开始)
     * 
     * @param str 需要高亮的字符串
     * @param key 关键字
     * @param className 高亮的类名
     * @return 高亮后的字符串
     */
    public static String addHighlightLeft(String str, String key, String className) {
        if (StringUtils.isBlank(str) || StringUtils.isBlank(key)) {
            return str;
        }
        if (str.startsWith(key)) {
            String temp1 = str.substring(0, key.length());
            String temp2 = str.substring(key.length());
            str = "<span class='" + className + "'>" + temp1 + "</span>" + temp2;
        }
        return str;
    }

    /**
     * 高亮关键字(左边开始，不区分大小写)
     * 
     * @param str 需要高亮的字符串
     * @param key 关键字
     * @param className 高亮的类名
     * @return 高亮后的字符串
     */
    public static String addHighlightLeftIgnoreCase(String str, String key, String className) {
        if (StringUtils.isBlank(str) || StringUtils.isBlank(key)) {
            return str;
        }
        if (str.toLowerCase().startsWith(key.toLowerCase())) {
            String temp1 = str.substring(0, key.length());
            String temp2 = str.substring(key.length());
            str = "<span class='" + className + "'>" + temp1 + "</span>" + temp2;
        }
        return str;
    }
}
